home *** CD-ROM | disk | FTP | other *** search
/ Technotools / Technotools (Chestnut CD-ROM)(1993).ISO / lang_c / cppmatrx / matrix.bak < prev    next >
Text File  |  1991-02-02  |  9KB  |  410 lines
  1. #include <stdlib.h>
  2. #include <iostream.h>
  3. #include <stdarg.h>
  4. #include <math.h>
  5.  
  6. #include "matrix.h"
  7.  
  8.  
  9. matrix::matrix (size_t matrix_length, ...)
  10. {
  11.    va_list argptr;
  12.    size_t elem_count;
  13.  
  14.    matrix_size = matrix_length;
  15.    matrix_data = new matrix_t [matrix_size*matrix_size];
  16.  
  17.    matrix_t *i;
  18.    size_t count;
  19.  
  20.    va_start (argptr, matrix_length);
  21.  
  22.    elem_count = matrix_size*matrix_size;
  23.  
  24.    for (i = matrix_data, count = 1; count <= elem_count; i++, count++)  {
  25.          *i = (matrix_t) (va_arg (argptr, matrix_t));
  26.       }
  27.  
  28.    va_end (argptr);
  29. }
  30.  
  31. matrix::matrix (char *dummy, size_t matrix_length,matrix_t fill_value)
  32. {
  33.    size_t elem_count;
  34.  
  35.    matrix_size = matrix_length;
  36.    matrix_data = new matrix_t [matrix_size*matrix_size];
  37.  
  38.    matrix_t *i;
  39.    size_t count;
  40.  
  41.    elem_count = matrix_size*matrix_size;
  42.  
  43.    for (i = matrix_data, count = 1; count <= elem_count; count++, i++)
  44.       *i = (matrix_t) fill_value;
  45. }
  46.  
  47. void matrix::print_matrix (void)
  48. {
  49.    matrix_t *i;
  50.    size_t row_count, column_count;
  51.  
  52.    cout << '\n';
  53.  
  54.    for (i = matrix_data, row_count = 0, column_count = 0; row_count < matrix_size; i++)   {
  55.          cout << *i << ' ';
  56.          if (column_count == (matrix_size - 1)) {
  57.                column_count = 0;
  58.                row_count++;
  59.                cout << '\n';
  60.             }
  61.                else
  62.                   column_count++;
  63.       }
  64. }
  65.  
  66. matrix::matrix (matrix &m)
  67. {
  68.    matrix_t *i, *j;
  69.    size_t count, elem_count;
  70.  
  71.    matrix_size = m.matrix_size;
  72.    elem_count = matrix_size*matrix_size;
  73.  
  74.    matrix_data = new matrix_t [elem_count];
  75.  
  76.    for (i = matrix_data, j = m.matrix_data, count = 1; count <= elem_count; count++, i++, j++)
  77.       *i = *j;
  78. }
  79.  
  80. matrix matrix::operator= (matrix &m)
  81. {
  82.  
  83.    size_t elem_count;
  84.    matrix_t *i, *j;
  85.  
  86.    size_t count;
  87.  
  88.    delete matrix_data;  // erase the current contents of the matrix on the left
  89.                         // side of the assignment
  90.  
  91.    matrix_size = m.matrix_size;
  92.    elem_count = matrix_size * matrix_size;
  93.  
  94.    matrix_data = new matrix_t [elem_count];  // allocate space for the new matrix, identical to the argument
  95.  
  96.    for (i = matrix_data, j = m.matrix_data, count = 1; count <= elem_count; count++, i++, j++)
  97.       *i = *j;
  98.  
  99.    return *this;
  100. }
  101.  
  102. matrix matrix::operator+ (matrix m)
  103. {
  104.    matrix temp ("*",matrix_size);
  105.    matrix_t *i, *j, *k;
  106.    size_t counter;
  107.    size_t elem_count;
  108.  
  109.    elem_count = matrix_size * matrix_size;
  110.  
  111.    for (i = matrix_data, j = m.matrix_data, k = temp.matrix_data, counter = 1;
  112.         counter <= elem_count; i++, j++, k++, counter++)
  113.            *k = *i + *j;
  114.  
  115.    return temp;
  116. }
  117.  
  118. matrix matrix::operator- (matrix m)
  119. {
  120.    matrix temp ("*",matrix_size);
  121.    matrix_t *i, *j, *k;
  122.    size_t counter;
  123.    size_t elem_count;
  124.  
  125.    elem_count = matrix_size * matrix_size;
  126.  
  127.    for (i = matrix_data, j = m.matrix_data, k = temp.matrix_data, counter = 1;
  128.         counter <= elem_count; i++, j++, k++, counter++)
  129.            *k = *i - *j;
  130.  
  131.    return temp;
  132. }
  133.  
  134.  
  135. inline void swap (matrix_t &a, matrix_t &b)
  136. {
  137.    matrix_t temp;
  138.  
  139.    temp = a;
  140.    a = b;
  141.    b = temp;
  142. }
  143.  
  144.  
  145. void transpose (matrix &m)
  146. {
  147.    size_t i,j;
  148.  
  149.    for (i = 2; i <= m.matrix_size; i++)
  150.       for (j = 1; j <= i-1; j++)
  151.          swap (m (i,j), m (j,i));
  152. }
  153.  
  154.  
  155. matrix minor (matrix m, size_t m_row, size_t m_column)
  156. {
  157.    matrix temp ("*", m.matrix_size-1);
  158.    size_t column, row;
  159.    size_t temp_column, temp_row;
  160.    
  161.    for (column = 1, temp_column = 1; column <= m.matrix_size; column++)  {
  162.          if (column != m_column) {
  163.                for (row = 1, temp_row = 1; row <= m.matrix_size; row++)
  164.                   if (row != m_row) {
  165.                      temp (temp_row, temp_column) = m (row, column);
  166.                      temp_row++;
  167.                   }
  168.  
  169.                temp_column++;
  170.             }
  171.       }
  172.  
  173.    return temp;
  174. }
  175.  
  176. #if 0
  177.  
  178. matrix_t det (matrix m)
  179. {
  180.  
  181.    int factor;
  182.  
  183.    if (m.matrix_size == 2)
  184.       return m (1,1)*m (2,2) - m (1,2)*m (2,1);
  185.          else  {
  186.                  matrix_t value = 0.0;
  187.                  size_t col;
  188.                  size_t temp_row, temp_col;
  189.                  size_t current_col;
  190.                  matrix temp ("*",m.matrix_size-1);
  191.  
  192.                  for (col = 1, factor = 1; col <= m.matrix_size; col++, factor *= (-1))   {
  193.                         for (current_col = 1, temp_col = 1; current_col <= m.matrix_size; current_col++)
  194.                            if (current_col != col)  {
  195.                               for (temp_row = 2; temp_row <= m.matrix_size; temp_row++)
  196.                                  temp (temp_row-1,temp_col) = m (temp_row,current_col);
  197.  
  198.                               temp_col++;
  199.                            }
  200.  
  201.                         value += m (1, col) * det (temp) * factor; 
  202.                     }
  203.  
  204.                  return value;
  205.             }
  206. }
  207.  
  208. #endif
  209.  
  210.  
  211. matrix_t det (matrix m)
  212. {
  213.    if (m.matrix_size == 2)
  214.       return m (1,1)*m (2,2) - m (1,2)*m (2,1);
  215.          else  {
  216.                  size_t i;
  217.                  matrix_t value = 0;
  218.  
  219.                  for (i = 1; i <= m.matrix_size; i++)
  220.                     value += m (1,i) * cofactor (m, 1, i);
  221.  
  222.                  return value;
  223.             }
  224. }
  225.  
  226.  
  227.  
  228. int matrix::operator== (matrix m)
  229. {
  230.  
  231.    if (matrix_size == m.matrix_size)
  232.       return ! memcmp (matrix_data, m.matrix_data, matrix_size*matrix_size);
  233.          else
  234.             return 0;
  235. }
  236.  
  237.  
  238. int matrix::operator!= (matrix m)
  239. {
  240.  
  241.    if (matrix_size == m.matrix_size)
  242.       return memcmp (matrix_data, m.matrix_data, matrix_size*matrix_size);
  243.          else
  244.             return 1;
  245. }
  246.  
  247. matrix operator* (matrix m, double r)
  248. {
  249.    matrix temp ("*",m.matrix_size);
  250.    matrix_t *i, *t;
  251.    size_t count, elem_count = m.matrix_size*m.matrix_size;
  252.  
  253.    for (i = m.matrix_data, t = temp.matrix_data, count = 1; count <= elem_count; i++, t++, count++)
  254.       *t = *i * r;
  255.  
  256.    return temp;
  257. }
  258.  
  259. matrix operator* (double r, matrix m)
  260. {
  261.    matrix temp ("*",m.matrix_size);
  262.    matrix_t *i, *t;
  263.    size_t count, elem_count = m.matrix_size*m.matrix_size;
  264.  
  265.    for (i = m.matrix_data, t = temp.matrix_data, count = 1; count <= elem_count; i++, t++, count++)
  266.       *t = *i * r;
  267.  
  268.    return temp;
  269. }
  270.  
  271. matrix operator* (matrix m, int r)
  272. {
  273.    matrix temp ("*",m.matrix_size);
  274.    matrix_t *i, *t;
  275.    size_t count, elem_count = m.matrix_size*m.matrix_size;
  276.  
  277.    for (i = m.matrix_data, t = temp.matrix_data, count = 1; count <= elem_count; i++, t++, count++)
  278.       *t = *i * r;
  279.  
  280.    return temp;
  281. }
  282.  
  283. matrix operator* (int r, matrix m)
  284. {
  285.    matrix temp ("*",m.matrix_size);
  286.    matrix_t *i, *t;
  287.    size_t count, elem_count = m.matrix_size*m.matrix_size;
  288.  
  289.    for (i = m.matrix_data, t = temp.matrix_data, count = 1; count <= elem_count; i++, t++, count++)
  290.       *t = *i * r;
  291.  
  292.    return temp;
  293. }
  294.  
  295. matrix_t cofactor (matrix m, size_t m_row, size_t m_column)
  296. {
  297.    int factor;
  298.  
  299.    if ((m_row+m_column) % 2)
  300.       factor = (-1);
  301.          else
  302.             factor = 1;
  303.  
  304.    return (matrix_t) factor * det (minor (m, m_row, m_column));
  305. }
  306.  
  307.  
  308. matrix matrix::operator- (void)
  309. {
  310.    matrix temp ("*",matrix_size);
  311.    matrix_t *i, *t;
  312.    size_t count, elem_count = matrix_size*matrix_size;
  313.  
  314.    for (i = matrix_data, t = temp.matrix_data, count = 1; count <= elem_count; i++, t++, count++)
  315.       *t = -*i;
  316.  
  317.    return temp;
  318. }
  319.  
  320. matrix matrix::operator* (matrix m)
  321. {
  322.    if (matrix_size != m.matrix_size)
  323.       matrix_error ("Cannot multiply matrices of different dimensions.");
  324.  
  325.    size_t i,j,k;
  326.    matrix temp ("*",matrix_size);
  327.  
  328.    for (i = 1; i <= matrix_size; i++)  {
  329.  
  330.          for (j = 1; j <= matrix_size; j++)  {
  331.                matrix_t value = 0;
  332.  
  333.                for (k = 1; k <= matrix_size; k++)
  334.                   value += get_elem (j,k)*m (k,i);
  335.  
  336.                temp (j,i) = value;
  337.             }
  338.       }
  339.  
  340.    return temp;
  341. }
  342.  
  343.  
  344. ostream& operator<< (ostream &s, matrix m)
  345. {
  346.    size_t i,j;
  347.  
  348.    s << '\n';
  349.  
  350.    for (i = 1; i <= m.matrix_size; i++)   {
  351.          for (j = 1; j <= m.matrix_size; j++)
  352.             s << m (i,j) << ' ';
  353.  
  354.          s << '\n';
  355.       }
  356.  
  357.    return s;
  358. }
  359.  
  360. istream& operator>> (istream &s, matrix &m)
  361. {
  362.    size_t i,j;
  363.  
  364.    delete m.matrix_data;
  365.    s >> m.matrix_size;
  366.    m.matrix_data = new matrix_t [m.matrix_size*m.matrix_size];
  367.  
  368.    for (i = 1; i <= m.matrix_size; i++)   
  369.       for (j = 1; j <= m.matrix_size; j++)   
  370.             s >> m (i,j);
  371.  
  372.    return s;
  373. }
  374.  
  375. void matrix_error (char *message)
  376. {
  377.    cerr << "\nMatrix error: " << message << '\n';
  378.    exit (1);
  379. }
  380.  
  381.  
  382. main (void)
  383. {
  384.    matrix matrix_a ("*",2);
  385.    matrix matrix_b ("*",2);
  386.    matrix matrix_c ("*",2);
  387.  
  388.    cout << "\nTesting matrix multiplication.\n";
  389.    cout << "\nPlease enter the first matrix:\n";
  390.    cin >> matrix_a;
  391.    cout << "\nPlease enter the second matrix:\n";
  392.    cin >> matrix_b;
  393.    cout << "\nYou have entered the following matrices:\n";
  394.    cout << "\nFirst:\n";
  395.    cout << matrix_a;
  396.    cout << "\nSecond:\n";
  397.    cout << matrix_b;
  398.  
  399.    cout << "\nThe product of these matrices is:\n";
  400.    matrix_c = matrix_a*matrix_b;
  401.    cout << matrix_c;
  402.    cout << '\n';
  403.  
  404.    return 0;
  405. }
  406.  
  407.  
  408.  
  409.  
  410.